In [1]:
import numpy as np #linear algebra module
import pandas as pd #data processing module
import matplotlib.pyplot as plt #to draw anything
import seaborn as sns #to draw anything
%matplotlib inline
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression, LogisticRegression
from sklearn import metrics
from mord import LogisticAT
from sklearn.metrics import make_scorer
from sklearn.model_selection import cross_val_score
from sklearn.metrics import mean_absolute_error
tb=pd.read_csv("lasvegas.csv")
In [8]:
tb.info()
In [4]:
tb.isna().sum() #empty fields checking
Out[4]:
In [5]:
countries=tb.groupby('User country')[['Score']].count() #let's see how many reviews from each country we got
countries=countries.sort_values(by='Score',ascending=False)#and sort them ofc
countries
#as we can see the majority of the guests is from english-speaking countries
Out[5]:
In [6]:
sns.pairplot(tb)
Out[6]:
In [7]:
sns.distplot(tb['Score'],kde=False)
Out[7]:
In [8]:
tb.columns
Out[8]:
In [2]:
#here I will try to predict how hotel stars and number of rooms can reflect to the score
X=tb[['Hotel stars', 'Nr. rooms','Nr. reviews', 'Nr. hotel reviews', 'Helpful votes']]
y=tb[['Score']]
In [3]:
corr = pd.DataFrame(data=tb, columns=['Hotel stars', 'Nr. rooms','Nr. reviews', 'Nr. hotel reviews', 'Helpful votes','Score'])
In [5]:
#As we can see y values do not correlate much vith X datapoints, the biggest dependence is with 'Hotel stars' values
#this only explains that number of reviews increases chances to be helpful to other users
sns.heatmap(corr.corr(),annot=True)
Out[5]:
In [3]:
X_train, X_test, y_train, y_test = train_test_split(X,y,test_size = 0.8, random_state = 101)
In [60]:
lm = LinearRegression()
lm.fit(X_train, y_train)
Out[60]:
In [61]:
prediction = lm.predict(X_test)
In [62]:
plt.scatter(y_test,prediction)
plt.boxplot(prediction)
#plt.boxplot(y_test)
Out[62]:
In [63]:
print('RMSE = ', np.sqrt(metrics.mean_squared_error(y_test, prediction)))
In [64]:
#lets try another type of regression and compare it to the linear one
model_linear = LinearRegression()
model_1vR = LogisticRegression(multi_class='ovr', class_weight='balanced')
model_multi = LogisticRegression(multi_class='multinomial', solver='lbfgs', class_weight='balanced')
model_ordinal = LogisticAT(alpha=0)
In [65]:
features = tb[['Nr. reviews', 'Nr. hotel reviews', 'Helpful votes', 'Pool', 'Gym',
'Tennis court', 'Spa', 'Casino', 'Free internet',
'Hotel stars', 'Nr. rooms', 'Member years']] #all except scores
target = tb[['Score']]
MAE = make_scorer(mean_absolute_error)
folds=5
MAE_linear = cross_val_score(model_linear,
features,
target,
cv=folds,
scoring=MAE)
MAE_1vR = cross_val_score(model_1vR,
features,
target,
cv=folds,
scoring=MAE)
MAE_multi = cross_val_score(model_multi,
features,
target,
cv=folds,
scoring=MAE)
In [66]:
print('Mean absolute error:' )
print('Linear regression: ', np.mean(MAE_linear))
print('Logistic regression (one versus rest): ', np.mean(MAE_1vR))
print('Logistic regression (multinomial): ', np.mean(MAE_multi))
In [67]:
from sklearn.metrics import accuracy_score
def acc_fun(target_true, target_fit):
target_fit = np.round(target_fit)
target_fit.astype('int')
return accuracy_score(target_true, target_fit)
acc = make_scorer(acc_fun)
folds = 5
acc_linear = cross_val_score(model_linear,
features,
target,
cv=folds,
scoring=acc)
acc_1vR = cross_val_score(model_1vR,
features,
target,
cv=folds,
scoring=acc)
acc_multi = cross_val_score(model_multi,
features,
target,
cv=folds,
scoring=acc)
In [68]:
print('Accuracy:' )
print('Linear regression: {:.2f}'.format(np.mean(acc_linear)))
print('Logistic regression (one versus rest): {:.2f}'.format(np.mean(acc_1vR)))
print('Logistic regression (multinomial): {:.2f}'.format(np.mean(acc_multi)))
In [69]:
#as we can see linear regression is most suitable for this current case
In [70]:
#in the code beneath I will do classification task
tb.describe()
Out[70]:
In [77]:
#we got 5 classes of coordinates on the plane
#now we'll visualize it
plt.figure(figsize = (20,20))
sns.stripplot(data=tb, x='Hotel stars', y='Helpful votes', hue='Score', size=15)
#'Hotel stars', 'Nr. rooms','Nr. reviews', 'Nr. hotel reviews', 'Helpful votes'
Out[77]:
In [40]:
tb.columns
Out[40]:
In [78]:
#KMean clustering for identification
from sklearn.cluster import KMeans
tb_clustered = tb[['Hotel stars','Helpful votes']]
kmeans = KMeans(n_clusters=5, random_state=0)
kmeans.fit(tb_clustered)
tb_clustered['Score'] = kmeans.labels_
plt.figure(figsize = (20,20))
sns.stripplot(data=tb_clustered, x='Helpful votes', y='Hotel stars', hue='Score', size=15)
Out[78]:
In [86]:
#KMean clustering did a good job for each hotel star, but let's try another method, DBSCAN
from sklearn.cluster import DBSCAN
tb_clustered = tb[['Hotel stars','Helpful votes']]
# The success of dbscan lies in choosing the right epsilon and min_samples values.
# Epsilon tells dscan what is the maximum euclidean distance we allow between neighbours,
# and min_samples tells us how many neighbours are required to accept a point to a class.
# These current settings are not perfect.
dbscan = DBSCAN(eps=1.5, min_samples=6)
dbscan.fit(tb_clustered)
tb_clustered['Score'] = dbscan.labels_
plt.figure(figsize = (20,20))
sns.stripplot(data=tb_clustered,x='Helpful votes', y='Hotel stars', hue='Score', size=15)
Out[86]:
In [88]:
%%time
# Let's take a look at AgglomerativeClustering
from sklearn.cluster import AgglomerativeClustering
tb_clustered = tb[['Hotel stars','Helpful votes']]
agglomerative = AgglomerativeClustering(n_clusters=5)
agglomerative.fit(tb_clustered)
tb_clustered['Score'] = agglomerative.labels_
plt.figure(figsize = (20,20))
sns.stripplot(data=tb_clustered, x='Helpful votes', y='Hotel stars', hue='Score', size=15)
# The problems are the same as with KMeans, but with more consistent results ie. Less random outliers.
Out[88]:
In [3]:
#Let's try non-linear model i.e. DecisionTreeClassifier
from sklearn.tree import DecisionTreeClassifier, export_graphviz
from sklearn import tree
from sklearn.datasets import load_wine
from IPython.display import SVG
from graphviz import Source
from IPython.display import display,Image
In [5]:
# feature matrix
X = tb[['Nr. reviews', 'Nr. hotel reviews', 'Helpful votes', 'Pool', 'Gym',
'Tennis court', 'Spa', 'Casino', 'Free internet',
'Hotel stars', 'Nr. rooms', 'Member years']]
# target vector
y = tb[['Score']]
# class labels
labels = ['Nr. reviews', 'Nr. hotel reviews', 'Helpful votes', 'Pool', 'Gym',
'Tennis court', 'Spa', 'Casino', 'Free internet',
'Hotel stars', 'Nr. rooms', 'Member years']
# print dataset description
estimator = DecisionTreeClassifier()
estimator.fit(X, y)
graph = Source(tree.export_graphviz(estimator, out_file='tree.dot', feature_names=labels,filled = True))
# Convert to png using system command (requires Graphviz)
from subprocess import call
call(['dot', '-Tpng', 'tree.dot', '-o', 'tree.png', '-Gdpi=600'])
# Display the tree we got
Image(filename = 'tree.png')
Out[5]:
In [6]:
#We can't really see what is in it so let's fix the depth of the tree
graph = Source(tree.export_graphviz(estimator, out_file='tree.dot', feature_names=labels,filled = True,max_depth = 3))
call(['dot', '-Tpng', 'tree.dot', '-o', 'tree.png', '-Gdpi=600'])
# And again display the new tree
Image(filename = 'tree.png')
Out[6]:
In [4]:
#Now it is visible much better
In [7]:
#The very last method - Random forest
from sklearn.ensemble import RandomForestClassifier
clf = RandomForestClassifier(max_depth=5, random_state=0)
clf.fit(X, y)
Out[7]:
In [11]:
#Using KNN for score prediction
from sklearn.neighbors import KNeighborsClassifier
knn = KNeighborsClassifier(n_neighbors=10)
knn.fit(X, y)
knn.score(X_test, y_test),clf.score(X_test, y_test)
Out[11]:
In [12]:
#Random Forest gave better score than KNN on test data
p = (list(clf.predict(X_test)))
len(p)
Out[12]:
In [17]:
Predictions = X_test
Predictions['Original_Score']= y
Predictions['pred_score'] = p
Predictions.head()
Out[17]:
In [18]:
plt.figure(figsize=(18, 5))
ax = plt.subplot()
d = list(range(0,len(Predictions)))
#plotting original score
p1 = plt.plot(d,Predictions['Original_Score'],'r-', label="Original Score", linewidth= 1 )
#plotting predicted score
p2 = plt.plot(d,Predictions['pred_score'],'b-', label="Predicted Score", linewidth= 1)
ax.set_title('Original Score vs Prediction score on test reviews data\n Using Random Forest')
ax.set_xlabel('review Id')
ax.set_ylabel('Score')
ax.legend(handles, labels)
handles, labels = ax.get_legend_handles_labels()
plt.show()
In [ ]: